/**
 * 播放记录工具函数
 * 用于保存和获取视频播放记录
 */

const apiConfig = require('../config/api-config.js')

/**
 * 保存播放记录到后端
 * @param {Number} userId 用户ID
 * @param {Number} contentId 内容ID
 * @param {Number} chapterId 章节ID
 * @param {Number} progress 播放进度（秒）
 * @returns {Promise}
 */
/**
 * 保存播放记录到本地存储
 * @param {Number} userId 用户ID
 * @param {Number} contentId 内容ID
 * @param {Number} chapterId 章节ID
 * @param {Number} progress 播放进度（秒）
 * @param {Object} courseInfo 课程信息（可选）
 * @param {Object} chapterInfo 章节信息（可选）
 * @returns {Promise}
 */
function savePlayRecord(userId, contentId, chapterId, progress, courseInfo = null, chapterInfo = null) {
  return new Promise((resolve, reject) => {
    // 参数验证
    if (!userId || !contentId || !chapterId || progress === undefined) {
      console.error('❌ 保存播放记录参数不完整:', { userId, contentId, chapterId, progress })
      reject(new Error('参数不完整'))
      return
    }

    try {
      const localKey = `playRecord_${userId}_${contentId}_${chapterId}`
      const localData = {
        userId,
        contentId,
        chapterId,
        progress: Math.floor(progress),
        timestamp: Date.now(),
        lastUpdate: new Date().toISOString(),
        // 保存课程和章节信息
        content: courseInfo || {},
        chapter: chapterInfo || {}
      }
      
      wx.setStorageSync(localKey, localData)
      console.log('✅ 播放记录已保存到本地存储:', localData)
      
      // 同时保存到播放记录列表
      const listKey = `playRecordList_${userId}`
      let playRecordList = wx.getStorageSync(listKey) || []
      
      // 查找是否已存在该记录
      const existingIndex = playRecordList.findIndex(record => 
        record.contentId === contentId && record.chapterId === chapterId
      )
      
      if (existingIndex >= 0) {
        // 更新现有记录
        playRecordList[existingIndex] = localData
      } else {
        // 添加新记录
        playRecordList.push(localData)
      }
      
      wx.setStorageSync(listKey, playRecordList)
      console.log('📋 播放记录列表已更新，共', playRecordList.length, '条记录')
      
      resolve(localData)
    } catch (error) {
      console.error('❌ 本地存储失败:', error)
      reject(error)
    }
  })
}

/**
 * 获取某个章节的播放记录
 * @param {Number} userId 用户ID
 * @param {Number} chapterId 章节ID
 * @returns {Promise}
 */
function getPlayRecordByChapter(userId, chapterId) {
  return new Promise((resolve, reject) => {
    try {
      const listKey = `playRecordList_${userId}`
      const playRecordList = wx.getStorageSync(listKey) || []
      
      const record = playRecordList.find(item => 
        item.userId === userId && item.chapterId === chapterId
      )
      
      if (record) {
        console.log('📖 找到章节播放记录:', record)
        resolve(record)
      } else {
        console.log('📖 未找到章节播放记录')
        resolve(null)
      }
    } catch (error) {
      console.error('❌ 获取章节播放记录失败:', error)
      reject(error)
    }
  })
}

/**
 * 获取某个课程的播放记录
 * @param {Number} userId 用户ID
 * @param {Number} contentId 内容ID
 * @returns {Promise}
 */
function getPlayRecordByContent(userId, contentId) {
  return new Promise((resolve, reject) => {
    try {
      const listKey = `playRecordList_${userId}`
      const playRecordList = wx.getStorageSync(listKey) || []
      
      const records = playRecordList.filter(item => 
        item.userId === userId && item.contentId === contentId
      )
      
      console.log('📚 找到课程播放记录:', records.length, '条')
      resolve(records)
    } catch (error) {
      console.error('❌ 获取课程播放记录失败:', error)
      reject(error)
    }
  })
}

/**
 * 获取用户所有播放记录
 * @param {Number} userId 用户ID
 * @returns {Promise}
 */
function getAllPlayRecords(userId) {
  return new Promise((resolve, reject) => {
    try {
      const listKey = `playRecordList_${userId}`
      const playRecordList = wx.getStorageSync(listKey) || []
      
      console.log('📋 获取用户所有播放记录:', playRecordList.length, '条')
      resolve(playRecordList)
    } catch (error) {
      console.error('❌ 获取播放记录列表失败:', error)
      reject(error)
    }
  })
}

/**
 * 删除播放记录
 * @param {Number} userId 用户ID
 * @param {Number} contentId 内容ID
 * @returns {Promise}
 */
function deletePlayRecord(userId, contentId) {
  return new Promise((resolve, reject) => {
    try {
      const listKey = `playRecordList_${userId}`
      let playRecordList = wx.getStorageSync(listKey) || []
      
      // 删除指定课程的播放记录
      const originalLength = playRecordList.length
      playRecordList = playRecordList.filter(record => 
        !(record.userId === userId && record.contentId === contentId)
      )
      
      wx.setStorageSync(listKey, playRecordList)
      
      const deletedCount = originalLength - playRecordList.length
      console.log('🗑️ 删除播放记录:', deletedCount, '条')
      
      resolve(true)
    } catch (error) {
      console.error('❌ 删除播放记录失败:', error)
      reject(error)
    }
  })
}

/**
 * 创建视频播放记录管理器
 * 用于在视频播放页面自动保存播放进度
 * @param {Object} options 配置选项
 * @param {Number} options.userId 用户ID
 * @param {Number} options.contentId 内容ID
 * @param {Number} options.chapterId 章节ID
 * @param {Number} options.saveInterval 保存间隔（毫秒），默认10000（10秒）
 * @returns {Object} 管理器对象
 */
function createPlayRecordManager(options) {
  const {
    userId,
    contentId,
    chapterId,
    courseInfo = null,
    chapterInfo = null,
    saveInterval = 10000 // 默认每10秒保存一次
  } = options

  let timer = null
  let currentProgress = 0

  return {
    /**
     * 开始自动保存
     * @param {Function} getProgress 获取当前播放进度的函数，返回秒数
     */
    start(getProgress) {
      if (timer) {
        clearInterval(timer)
      }

      timer = setInterval(() => {
        const progress = getProgress()
        if (progress && progress > 0) {
          currentProgress = progress
          
          console.log('⏰ 定时保存播放记录:', {
            userId,
            contentId,
            chapterId,
            progress
          })
          
          // 保存播放记录，静默失败
          savePlayRecord(userId, contentId, chapterId, progress, courseInfo, chapterInfo).catch(err => {
            console.error('❌ 自动保存播放记录失败:', err)
          })
        } else {
          console.log('⏸️ 跳过保存（进度为0或无效）:', progress)
        }
      }, saveInterval)

      console.log('播放记录自动保存已开启，间隔:', saveInterval, 'ms')
    },

    /**
     * 停止自动保存
     * @param {Number} finalProgress 最终播放进度（可选）
     */
    stop(finalProgress) {
      if (timer) {
        clearInterval(timer)
        timer = null
      }

      // 保存最终进度
      const progress = finalProgress || currentProgress
      if (progress > 0) {
        savePlayRecord(userId, contentId, chapterId, progress, courseInfo, chapterInfo).catch(err => {
          console.error('保存最终播放记录失败:', err)
        })
      }

      console.log('播放记录自动保存已停止')
    },

    /**
     * 立即保存当前进度
     * @param {Number} progress 播放进度（秒）
     */
    saveNow(progress) {
      currentProgress = progress
      return savePlayRecord(userId, contentId, chapterId, progress, courseInfo, chapterInfo)
    }
  }
}

/**
 * 测试播放记录API连接（本地存储版本）
 * @returns {Promise}
 */
function testPlayRecordAPI() {
  return new Promise((resolve, reject) => {
    try {
      // 测试本地存储是否可用
      const testKey = 'test_playRecord_' + Date.now()
      const testData = { test: true, timestamp: Date.now() }
      
      wx.setStorageSync(testKey, testData)
      const retrieved = wx.getStorageSync(testKey)
      wx.removeStorageSync(testKey)
      
      if (retrieved && retrieved.test === testData.test) {
        console.log('✅ 本地存储测试通过')
        resolve({ statusCode: 200, message: '本地存储正常' })
      } else {
        reject(new Error('本地存储测试失败'))
      }
    } catch (error) {
      console.error('❌ 本地存储测试失败:', error)
      reject(error)
    }
  })
}

/**
 * 网络状态监听器
 */
const networkMonitor = {
  listeners: [],
  initialized: false,
  
  /**
   * 初始化网络监听
   */
  init() {
    if (this.initialized) return
    
    // 监听微信小程序的网络状态变化
    if (typeof wx !== 'undefined' && wx.onNetworkStatusChange) {
      wx.onNetworkStatusChange((res) => {
        console.log('网络状态变化:', res)
        if (res.isConnected) {
          this.trigger('networkRestored')
        } else {
          this.trigger('networkLost')
        }
      })
      this.initialized = true
      console.log('网络状态监听已初始化')
    } else {
      console.warn('wx.onNetworkStatusChange 不可用，网络监听功能将被禁用')
    }
  },
  
  /**
   * 添加网络状态监听器
   * @param {Function} callback 回调函数
   */
  addListener(callback) {
    if (typeof callback === 'function') {
      this.listeners.push(callback)
      // 自动初始化
      this.init()
    }
  },
  
  /**
   * 移除网络状态监听器
   * @param {Function} callback 回调函数
   */
  removeListener(callback) {
    const index = this.listeners.indexOf(callback)
    if (index > -1) {
      this.listeners.splice(index, 1)
    }
  },
  
  /**
   * 触发网络状态事件
   * @param {String} event 事件类型
   */
  trigger(event) {
    this.listeners.forEach(callback => {
      try {
        callback(event)
      } catch (error) {
        console.error('网络状态监听器执行错误:', error)
      }
    })
  }
}

/**
 * 获取用户所有播放记录（离线版本）
 * @param {Number} userId 用户ID
 * @returns {Array} 播放记录数组
 */
function getAllPlayRecordsOffline(userId) {
  try {
    const listKey = `playRecordList_${userId}`
    const playRecordList = wx.getStorageSync(listKey) || []
    
    console.log('📋 获取离线播放记录:', playRecordList.length, '条')
    return playRecordList
  } catch (error) {
    console.error('❌ 获取离线播放记录失败:', error)
    return []
  }
}

module.exports = {
  savePlayRecord,
  getPlayRecordByChapter,
  getPlayRecordByContent,
  getAllPlayRecords,
  deletePlayRecord,
  createPlayRecordManager,
  testPlayRecordAPI,
  networkMonitor,
  getAllPlayRecordsOffline
}

